/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controlador;

import controlador.exceptions.NonexistentEntityException;
import controlador.exceptions.PreexistingEntityException;
import java.io.Serializable;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Persistence;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import modelo.DocumentoArchivado;

/**
 *
 * @author Mike
 */
public class DocumentoArchivadoJpaController implements Serializable {

    public DocumentoArchivadoJpaController() {
       
    }
    private static final EntityManagerFactory emf = conexion.getEmf();

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(DocumentoArchivado documentoArchivado) throws PreexistingEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            em.persist(documentoArchivado);
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findDocumentoArchivado(documentoArchivado.getIdDocumento()) != null) {
                throw new PreexistingEntityException("DocumentoArchivado " + documentoArchivado + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(DocumentoArchivado documentoArchivado) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            documentoArchivado = em.merge(documentoArchivado);
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = documentoArchivado.getIdDocumento();
                if (findDocumentoArchivado(id) == null) {
                    throw new NonexistentEntityException("The documentoArchivado with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            DocumentoArchivado documentoArchivado;
            try {
                documentoArchivado = em.getReference(DocumentoArchivado.class, id);
                documentoArchivado.getIdDocumento();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The documentoArchivado with id " + id + " no longer exists.", enfe);
            }
            em.remove(documentoArchivado);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<DocumentoArchivado> findDocumentoArchivadoEntities() {
        return findDocumentoArchivadoEntities(true, -1, -1);
    }

    public List<DocumentoArchivado> findDocumentoArchivadoEntities(int maxResults, int firstResult) {
        return findDocumentoArchivadoEntities(false, maxResults, firstResult);
    }

    private List<DocumentoArchivado> findDocumentoArchivadoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(DocumentoArchivado.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public DocumentoArchivado findDocumentoArchivado(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(DocumentoArchivado.class, id);
        } finally {
            em.close();
        }
    }

    public int getDocumentoArchivadoCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<DocumentoArchivado> rt = cq.from(DocumentoArchivado.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
           
        }
    }
    
    
    public ArrayList<DocumentoArchivado> buscarPor (String tipo, String parametro)
    {
        
        ArrayList<DocumentoArchivado> rta = new ArrayList<>();
        
        if (tipo.contains("todos"))
        
            return (new ArrayList<>(findDocumentoArchivadoEntities()));
        
        else
        
        {
            
            
        for (DocumentoArchivado doc : findDocumentoArchivadoEntities())
        {
        switch (tipo)
        {
            case "Titulo":
            {
                
                if (doc.getTitulo().toLowerCase().contains(parametro.toLowerCase()))
                {
                    rta.add(doc);
                }
                break;
            }
            
                case "Autor":
            {
                 if (doc.getAutor().toLowerCase().contains(parametro.toLowerCase()))
                {
                    rta.add(doc);
                }
                break;
            }
            
            case "Tema":
            {
                 if (doc.getTema().toLowerCase().contains(parametro.toLowerCase()))
                {
                    rta.add(doc);
                }
                break;
            }
            
            case "Director":
            {
                 if (doc.getDirector().toLowerCase().contains(parametro.toLowerCase()))
                {
                    rta.add(doc);
                }
                break;
            }
                
            case "Año":
            {
                DateFormat df = new SimpleDateFormat("yyyy");
                String fecha = df.format(doc.getFecha());
                 if (fecha.contains(parametro))
                {
                    rta.add(doc);
                }
                break;
            }
                
            case "Facultad":
            {
                 if (doc.getFacultad().toLowerCase().contains(parametro.toLowerCase()))
                {
                    rta.add(doc);
                }
                break;
            }
            
        }
        }
        return rta;
        
        }
    }
           
    
    public void modificarAtributosDocumento(int id, String titulo ,String facultad ,String autor,String fecha ,
    String tema,String director,String numpagina)
    {
        String[] fechaformat = fecha.split("/");
            fecha = fechaformat[2] + "-" + fechaformat[0] + "-" + fechaformat[1];

            SimpleDateFormat formatoDelTexto = new SimpleDateFormat("yyyy-MM-dd");
            Date momento = null;
        try {
            momento = formatoDelTexto.parse(fecha);
        } catch (ParseException ex) {
            Logger.getLogger(DocumentoArchivadoJpaController.class.getName()).log(Level.SEVERE, null, ex);
        }
            
        DocumentoArchivado doc = findDocumentoArchivado(id);
        DocumentoArchivado newdoc = new DocumentoArchivado(doc.getIdDocumento(), facultad, titulo, tema, autor, momento, 
                numpagina, doc.getDocumento(), director);
        try {
            edit(newdoc);
        } catch (NonexistentEntityException ex) {
            Logger.getLogger(DocumentoArchivadoJpaController.class.getName()).log(Level.SEVERE, null, ex);
        } catch (Exception ex) {
            Logger.getLogger(DocumentoArchivadoJpaController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
  
    
}
